package com.woniu.cloud.storeassembly.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.woniu.cloud.api.StoreServiceMiddleApi;
import com.woniu.cloud.common.dto.Result;
import com.woniu.cloud.entity.TStore;
import com.woniu.cloud.entity.TStoreServiceMiddle;
import com.woniu.cloud.storeassembly.config.RedissonConfig;
import com.woniu.cloud.storeassembly.mapper.TStoreMapper;
import com.woniu.cloud.storeassembly.mapper.TStoreServiceMiddleMapper;
import com.woniu.cloud.storeassembly.service.ITStoreService;
import com.woniu.cloud.storeassembly.service.ITStoreServiceMiddleService;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.*;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * <p>
 * 店铺表 服务实现类
 * </p>
 *
 * @author Lucas
 * @since 2021-09-22
 */
@Service
@Slf4j
public class TStoreServiceImpl extends ServiceImpl<TStoreMapper, TStore> implements ITStoreService {

    @Resource
    private ITStoreService storeService;

    @Resource
    private TStoreMapper storeMapper;

    @Resource
    private RedissonClient redissonClient;

    @Resource
    private TStoreServiceMiddleMapper storeServiceMiddleMapper;


    private Boolean nearBool=false;

    private RGeo<Integer> geo(){
        return redissonClient.getGeo("near");
    }

    public TStore updateRedis(Integer storeId){
        log.info("缓存修改->id:{}",storeId);
        TStore store = storeMapper.selectById(storeId);
        log.info("修改结果->{}",store);
        return store;
    }


    public TStore insertRedis(Integer storeId){
        log.info("缓存添加->id:{}",storeId);
        TStore store = storeMapper.selectById(storeId);
        log.info("缓存结果->{}",store);
        if (null != store) {
            storeService.insertRedisNear(store);
        }
        return store;
    }
    public void insertRedisNear(TStore store) {
        log.info("near缓存添加->store数据:{}", store);
        GeoEntry geoEntry = new GeoEntry(store.getStoreLongitude(), store.getStoreLatitude(), store.getStoreId());
        geo().addAsync(geoEntry);
        log.info("near缓存成功->");
    }
    public void removeRedisNear(GeoPosition geoPosition) {
        log.info("near缓存删除->geoPosition:{}",geoPosition);
        geo().remove(geoPosition);
        log.info("near缓存成功->");
    }

    @Override
    public Result getStoreByStoreId(Integer storeId) {
        TStore store = storeService.insertRedis(storeId);
        if (null!=store) {
            log.info("查询结果->{}",store);
            return Result.success("该店铺存在",store);
        }
        return Result.fail("该店铺不存在",null);
    }

    @Override
    public Result insertStore(TStore store) {

        store.setStoreRate(0.0);
        store.setStoreServiceNumber(0);
        store.setStoreStatus(2);
        store.setStoreConsumerNumber(0);
        store.setStoreTurnover(0.0);
        store.setStoreScore(0);
        store.setStorePay(new BigDecimal(0));
        int insert = storeMapper.insert(store);
        if (0!=insert) {
            log.info("添加成功->{}",store);
            storeService.insertRedis(store.getStoreId());
            return Result.success("添加成功",store);
        }
        return Result.fail("添加失败",null);
    }

    @Override
    public Result updateStore(TStore store) {
        UpdateWrapper<TStore> wrapper = new UpdateWrapper<>();
        wrapper.eq("store_id",store.getStoreId())
        .set(null!=store.getStoreName()&&""!=store.getStoreName(),"store_name",store.getStoreName())
        .set(null!=store.getStoreAddress()&&""!=store.getStoreAddress(),"store_address",store.getStoreAddress())
        .set(null!=store.getStorePrincipal()&&""!=store.getStorePrincipal(),"store_principal",store.getStorePrincipal())
        .set(null!=store.getStorePhone()&&""!=store.getStorePhone(),"store_phone",store.getStorePhone())
        .set(null!=store.getStoreLongitude()&&0!=store.getStoreLongitude(),"store_longitude",store.getStoreLongitude())
        .set(null!=store.getStoreLatitude()&&0!=store.getStoreLatitude(),"store_latitude",store.getStoreLatitude())
        .set(null!=store.getStoreRate(),"store_rate",store.getStoreRate())
        .set(null!=store.getStoreServiceNumber(),"store_service_number",store.getStoreServiceNumber())
        .set(null!=store.getStoreStatus(),"store_status",store.getStoreStatus())
        .set(null!=store.getStoreAccount()&&""!=store.getStoreAccount(),"store_account",store.getStoreAccount())
        .set(null!=store.getStoreConsumerNumber()&&0!=store.getStoreConsumerNumber(),"store_consumer_number",store.getStoreConsumerNumber())
        .set(null!=store.getStoreTurnover()&&0!=store.getStoreTurnover(),"store_turnover",store.getStoreTurnover())
        .set(null!=store.getStoreScore(),"store_score",store.getStoreScore())
        .set(null!=store.getStorePhone()&&""!=store.getStorePhone(),"store_photo",store.getStorePhone())
        .set(null!=store.getStoreDetail()&&""!=store.getStoreDetail(),"store_detail",store.getStoreDetail());
        int insert = storeMapper.update(null,wrapper);
        if (0!=insert) {
            log.info("修改成功->{}",store);
            storeService.updateRedis(store.getStoreId());
            return Result.success("修改成功",null);
        }
        return Result.fail("修改失败",null);
    }

    @Override
    public Result getStoreList(Integer serviceId,Double storeLongitude, Double storeLatitude ,Double radius) {

        Map<Integer, GeoPosition> citiesWithPositions = geo().radiusWithPosition(storeLongitude, storeLatitude, radius, GeoUnit.KILOMETERS);
        List<TStore> list =new ArrayList<>();
        if (0!=citiesWithPositions.size()) {
            for (Map.Entry<Integer, GeoPosition> entry : citiesWithPositions.entrySet()) {

                try {
                    log.info("修改成功entry.getKey()->{}",entry.getKey());
                    Integer key = entry.getKey();

                    log.info("getKey()->{}",key);
                    TStore e = insertRedis(key);
                    QueryWrapper<TStoreServiceMiddle> wrapper = new QueryWrapper<>();
                    wrapper.eq("store_service_middle_store_id",e.getStoreId());

                    List<TStoreServiceMiddle> lists = storeServiceMiddleMapper.selectList(wrapper);
                    if (0!=lists.size()) {
                        lists.forEach(l->{
                            if (l.getStoreServiceMiddleSecondServiceId()==serviceId) {
                                list.add(e);
                            }
                        });
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if (0!=list.size()) {
                return Result.success("附近存在"+list.size()+"家店铺",list);
            }
        }
        return Result.fail("附近没有店铺,请尝试扩大搜索范围",null);



    }

    @Override
    public Result insertStorePay(Integer storeId, BigDecimal payNum) {
        UpdateWrapper<TStore> wrapper = new UpdateWrapper<>();
        TStore store = storeMapper.selectById(storeId);
        BigDecimal add = store.getStorePay().add(payNum);
        if (0>add.compareTo(BigDecimal.ZERO)) {
            return Result.fail("账户余额不足",null);
        }
        wrapper.eq("store_id",storeId)
                .setSql("store_pay=store_pay+"+payNum);
                int insert = storeMapper.update(null,wrapper);
        if (0!=insert) {
            log.info("账户修改成功->{}");
            return Result.success("账户修改成功",null);
        }
        return Result.fail("账户修改失败",null);

    }
}
